baweaver

# 1 + 1
AstBuilder.build('1 + 1').to_ast.source
=> "1 + 1"

# From s-expressions
ast = AstBuilder.build { s(:send, s(:int, 1), :+, s(:int, 1)) }.to_ast
=> s(:send, s(:int, 1), :+, s(:int, 1))

# Current
ast.source

baweaver

# Original Code
hash = { something: 'fun' }
method_called(with, some, hash)

# AST
(begin
  (lvasgn :hash
    (hash
      (pair
        (sym :something)

baweaver

(def :route
  (args
    (arg :verb)
    (arg :path)
    (optarg :options
      (hash))
    (blockarg :block))
  (begin
    (...)
    (lvasgn :signature

baweaver

# Bad - Hard to read
some.really.long.chain_of_things(:with,
                                 :arguments,
                                 :that,
                                 :are,
                                 :out_here,
                                 :is_unreadable,
                                 :at_a_glance)

# Good - Eye doesn't flow far right then

baweaver

names = %w(
  @OtherChrisPine @DaveAronson @mellowfish @ktcarrel18 @yvonesre @molbrwn @_MylesHigh_ @DoodlingDev @nilsding @mae701
)

totally_random_results = "Lemur fun!"
  .chars
  .map(&:ord)
  .zip(names.shuffle.map(&:ord))
  .sample
  .sum

baweaver

Cons = Struct.new(:head, :tail)

case Cons[1, Cons[2]]
in Cons[head. tail] then [head, tail]
end
# => [1, #<struct Cons head=2, tail=nil>]
  
case Cons[1, Cons[2]]
in Cons[1, Cons[head, tail]] then [head, tail]
end

baweaver

case { it: { works: { on: 1, nested: 'hashes' }, cool: true } }
in it: { works: { on: Integer, nested: String }, cool: TrueClass }
  true
else
  false
end
# => true

case [{ that: { includes: [:this, :too] }}, { more: 'splats'}, {see?: true}]
in [{ that: { includes: Array } }, *]

baweaver

Pattern Matching

Pattern match statements are an extension of the case expression. They introduce a new keyword to case statements: in.

The in expression

in is used in place of when to use pattern matching behaviors. These two syntaxes cannot be mixed.

An in expression is different from when in that it allows one to match against data structures:

baweaver

class Symbol
  def ap(*applied_args)
    -> *block_args {
      if applied_args.empty?
        receiver, *new_args = block_args[0]
        receiver.send(self, *new_args)
      else
        self.to_proc.call(*block_args, *applied_args)
      end
    }

baweaver

Ruby programming
And Gems pushed to GitHub
Cloud based deployments and CI / CD
Tests that will pass on the first try
These are a few of my favorite things

Just Rails new app name
and omakase thinking
convention o'er configuration
and sane default settings