Huh, I just realized why `with` bugs me so much, it looks like `for` but
does not act like it, has nothing to do with enumeration, but the `<-` all
over the place make it feel like it should. The `<-` operator is not being
used consistently across the language. o.O
On Thursday, August 25, 2016 at 10:00:45 AM UTC-6, OvermindDL1 wrote:
>
> On Thursday, August 25, 2016 at 9:13:00 AM UTC-6, José Valim wrote:
>>
>> (while using `=` instead of `<-` while having the same features, and more)
>>>
>>
>> Coincidentally that's the one thing I dislike about happy: the overriding
>> of the operator =. <- was made to be used exactly in situations such like
>> this and that's why it has no semantics outside of existing constructs. :)
>>
>
> Heh, that is one of the things that I really do like about happy, it
> unifies the 'matching' to be fully powerful in all cases. For example
> instead of just doing:
> ```elixir
> {:ok, str} = get_a_string_or_whatever() # Does not make sure `str`
> is_binary
>
> # -- or --
> case get_a_string_or_whatever() do
> {:ok, str} when is_binary(str) -> :blah # This makes sure `str`
> is_binary, but wow is it wordy
> end
>
> # -- or happy's way --
> {:ok, str} when is_binary(str) = get_a_string_or_whatever() # Enforce
> entire matching semantics, inline!
> ```
>
> I do like `<-` and `->` but when I see them I think of list stuff (I'm an
> old erlang programmer) and certainly not inline matching enforcement. Like
> using `<-` in for's makes sense to me, you are creating a new looping
> 'scope', where `=`'s do not. I think the same thing in with/happy, the <-
> is creating a new looping scope, except that it isn't, there is no loop, no
> enumeration work, instead it just doing doing a match/when, which should
> just be done and supported by `=` everywhere as `=` is a matching construct.
>
> Personally, I'd change Elixir so that `=` supports `when`, just naturally
> and everywhere, and this is in fact my main usage of `happy_path`, to
> enforce a specific match or fail out. I would also make `<-` work only on
> comprehension-style things, where something will be looped (I have a few
> ideas for this too), and `->` only for case-style blocks, although
> personally I'd probably make case something like:
> ```elixir
> case something() do
> {:ok, str} when is_binary(str) do
> something_in_a_body()
> end
> {:ok, _}, do: {:error, :invalid_type}
> {:err, reason} = e, do: e
> end
> ```
> Although personally not with 'do', but that is an easy to match construct
> in elixir, but the thing is that it makes defined blocks with a do/end
> instead of arbitrary `->` that just happens to end when another `->` is
> encountered. It seems magical in how those rules work (even though I know
> how the parsing works internally).
>
>
> Err, too much of a tangent, in essence: `with` using `<-` makes me think
> comprehension-loops, not matching, and it bugs the ever-living-tar out of
> me especially since `=` is already the matching operator (just needs to be
> buffed to support `when`). ^.^
>
>
>
> On Thursday, August 25, 2016 at 9:22:38 AM UTC-6, Drew Olson wrote:
>>
>> Has there been consideration of adding a "happy-like" macro version of
>> with (that has the same syntax as happy, but with <-)? I've also
>> implemented something like this locally for my projects, I find it reads
>> more pleasantly.
>>
>> Obviously, this works fine for me but if many folks are interested in
>> this syntactic form, perhaps including the alternative in elixir itself
>> makes sense.
>>
>
> Not done yet, but the author is *very* responsive and if asked I'm sure he
> would add such a variant (maybe call it `happy_with`?). I really really
> *really* hate using `<-` as a matching construct, that is `=`'s job. ^.^
>
--
You received this message because you are subscribed to the Google Groups
"elixir-lang-core" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To view this discussion on the web visit
https://groups.google.com/d/msgid/elixir-lang-core/8f38b61c-a379-4ed3-8526-83e315aee3c8%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
