Website

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """



























    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """
    # Play allows you to pass words around as arguments, and even construct anonymous words.
    # We call them quotations. Other languages call them anonymous functions.

    # For this example, let's bring back the Coordinate type from the previous lesson.

    deftype: Coordinate
    : x Int
    : y Int

    # Now, imagine we want to create a word that allows you to modify the 'x' member in any way imaginable.
    # This is a good use case for quotations.

    def: update-x
    type: Coordinate [ Int -- Int ] -- Coordinate
    : swap    # bring Coordinate to the top of the stack
      dup x>  # read value of x without loosing the original Coordinate
      -rotate # rotates the three top stack elements counter-clockwise
      !       # execute qutotation
      >x      # set x to whatever was returned by quotation

    def: main
    entry: true
    : 1 2 >Coordinate
      [ 1 + ] update-x
      x>

    # Quotations are wrapped in brackets. Think of them as inline word definitions.
    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """























    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """
    # Play supports the concept of a Union type

    defunion: State
    : On
    : Off

    deftype: On
    deftype: Off

    # This defines a Union of On and Off, called State.
    # Whenever you use State as a type, you're saying that it really could be either On or Off.
    # To handle such types we need to use multi-words, which are words with a definition that depends on the type that is actually present.

    defmulti: state->int
    type: State -- Int
    when: On
      drop 1
    when: Off
      drop 0

    def: main
    entry: true
    : >On state->int
    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """

















    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """
    # Multi words allows you to be very specific about when a specific condition applies.

    deftype: Coordinate
    : x Int
    : y Int

    defmulti: origo?
    type: Coordinate -- Int
    when: Coordinate( x 0 y 0 )
      drop 1
    when: Coordinate
      drop 0

    def: main
    entry: true
    : 1 1 >Coordinate
      origo?
    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """



































    """

    , content = String.trim <| String.unindent content
    }


content : String
content =
    """
    # Unions allow for some interesting API designs.
    # Let's implement a List data structure.

    defunion: List a
    : NonEmptyList a
    : EmptyList

    deftype: NonEmptyList a
    : first a
    : rest (List a)

    deftype: EmptyList

    # Notice retrieving the first element of a list can only be done if you have a NonEmptyList.
    # Also notice that a lowercased type acts as a placeholder for any type, a generic type.

    def: push
    type: (List a) a -- (NonEmptyList a)
    : swap >NonEmptyList

    defmulti: first-or-default
    type: (List a) a -- a
    when: NonEmptyList
      drop first>
    when: EmptyList
      swap drop

    # Here we can specify that the result of adding an element to a List, always result in a NonEmptyList.
    # A NonEmptyList is still a List, though.

    def: main
    entry: true
    : >EmptyList
      10 push
      0 first-or-default # Could have use 'first>' here
    """