You're right that what I wrote earlier has no way to deal with a Maybe
field. I think it could be generalized to handle Maybe fields, but then we
could also think of something that is neither a record nor a Maybe of a
record, ...
Anyway, it is not at all pretty but here is a quick idea. First let me
summarize the previous idea using the notation that works best for Maybes:
Suppose that 'a' is of type A, a record, which contains a field called b of
type B, which is a record, which contains a field called c which is also a
record of type C, which contains a field called d, which is also a record
of type D, which contains a field called e, of any type E, and that f is a
function of type f : E -> X where X is any type. Also suppose that ... is
an arbitrary elm expression of type E.
Then what I wrote before suggests that we can write:
a.b.c.d.e : E
and, since
a.b.c.d : D
we can write
{ a.b.c.d | e = f ... } : D -- where ... is any elm expression which is a
valid argument for f.
Also, we have
a.b.c : C
as well as
{ a.b.c | d.e = f ... } : C
and so on. So I like this notation up until this point -- it is exactly as
I described in my previous post. However in what follows, I hope to show
that adding Maybe's is possible but rather ugly, and while I think it is
possible I don't recommend it. It is just a mental experiment.
In Swift there is a ? operator for dereferencing fields conditionally.
So if everything is just as described above except that c is of type Maybe
C, where C is a record type as described above, then we can write this in a
similar style to Swift:
a.b.c?.d.e : Maybe E
meaning that if the value of a.b.c is (Just cValue), then a.b.c?.d.e is
(Just cValue.d.e)
but
if a.b.c is Nothing, then a.b.c?.d.e is Nothing.
Similarly we could have
a.b.c?.d : Maybe D
with the obvious semantics.
However a.b : B
and a : A
I am not a Swift person, but based on my limited understanding of that
language, that is what their ? dereference operator means. Anyone please
correct me here.
And if that syntax were ever to find its way into elm (I'm not suggesting
that it should, but just addressing this very specific hypothetical
question of how it would work with this possible record syntax): then we
could also have expressions like this:
{ a.b.c?.d | e = f ... } : Maybe D
And this would be
Just { cValue.d | e = f ... }
if c is (Just cValue), but it would be Nothing if c is Nothing.
Similarly you could have:
{ a.b | c?.d.e = f ...} : B
meaning the value of type B in which c.d.e is set to (f ...) if c is (Just
cValue) but in which nothing changes if c is Nothing.
It is crazy but it looks well-defined to me. Caveat I am not a programming
languages person.
Having said all this, my instinct is that mixing record syntax with ?
dereference is rather unwieldy. And I would not recommend that we go that
far. Just my opinion. However I hope that just the records of records of
records aspect gets some consideration. :-)
--
You received this message because you are subscribed to the Google Groups "Elm
Discuss" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
