Pyret Programming Language

stress-free to-celsius(f):
  (f - 32) (5 / 9)
discontinue

for each and every(str from [list: "Ahoy", "world!"]):
  print(str)
discontinue

stress-free sum(l):
  circumstances (Checklist) l:
    | empty => 0
    | link(first, relaxation) => first + sum(relaxation)
  discontinue
where:
  sum([list: ]) is 0
  sum([list: 1, 2, 3]) is 6
discontinue

records BinTree:
  | leaf
  | node(cost, left :: BinTree, genuine :: BinTree)
discontinue

test:
  stress-free receive-living(url):
    inquire of({
        url: url,
        verb: "receive",
        params: [list: ]
      }).living-code
  discontinue
  receive-living("http://google.com/") is 200
discontinue

Some thoughts on syntax

We judge indentation is serious for readable code, but we receive no longer
decide the whitespace of this design to uncover its that formulation. Slightly,
the that formulation of this design might perchance also simply silent decide its indentation
structure. Indentation turns into simply every other context-beautiful rule.

Unambiguous syntax (the procedure within the back of explicit discontinue delimiters)
formulation that you just would perchance even reproduction-and-paste code from electronic mail or the Web, and its that formulation might perchance well maybe no longer
change. Your IDE permit you reindent code without caring that doing so will
change the that formulation of this design.

We haven’t yet selected the indentation guidelines because we want to scrutinize
the language in employ for a while sooner than we codify these.

eps = 0.001
stress-free d-dx(f):
  doc: "Approximate the by-product of f"
  lam(x): (f(x + eps) - f(x)) / eps discontinue
where:
  stress-free square(x): x x discontinue
  stress-free around(delta, procedure):
    lam(right): num-abs(right - procedure)  

point-recommendations = {
  formulation dist(self, somewhat about a):
    ysquared = num-expt(somewhat about a.y - self.y, 2)
    xsquared = num-expt(somewhat about a.x - self.x, 2)
    num-sqrt(ysquared + xsquared)
  discontinue
}

stress-free receive-point(x, y):
  point-recommendations.{ x: x, y: y }
discontinue

test:
  p1 = receive-point(1, 2)
  p2 = receive-point(1, 5)

  p1.dist(p2) is 3
discontinue

Annotations

Most “scripting” languages receive no longer strengthen checking annotations on parameters
out of the sphere, Pyret does.

Python

def square(n : int) -> int:
  return n n
square("5")
# Error at multiplication:
# Can no longer multiply sequence by
# non-int of kind 'str'

Pyret

stress-free square(n :: Quantity) -> Quantity:
  n n
discontinue
square("5")
# With kind checker off:
# The Quantity annotation used to be no longer
# delighted by the cost "5"

# With kind checker on:
# Quantity is incompatible with String

No longer valuable Annotations

Nonetheless Pyret doesn’t force you to annotate all the pieces, as some somewhat about a
languages discontinue.

Java

static int square(int n) {
  return n n;
} 

Pyret

stress-free square(n) -> Quantity:
  n n
discontinue

Refinements in Annotations

Pyret permits you to (optionally) describe refinements of files.

Python

def insert(e, s):
  # tree insertion but with
  # invariants neither
  # acknowledged nor checked

Pyret

stress-free insert(e :: Quantity,
           s :: BST % (is-balanced))
    -> BST % (is-balanced):
  # self-balancing tree insertion
discontinue

Numbers

Pyret has numbers, because we judge an 8GB machine might perchance also simply silent no longer limit
students to the employ of simply 32 bits.

Java

// right here is no longer genuine
((1 / 3) 3) == 1

Pyret

# right here is good
((1 / 3) 3) == 1

Easy Trying out

Friction within the checking out project makes it hard to work even straightforward unit tests
into early programming. Pyret eliminates boilerplate to position checking out in its
rightful net online page within the programming project.

Python

import unittest
class TestLists(unittest.TestCase):
  def test_empty_first(self):
    self.assertRaises(IndexError, lambda: [][0])

  def test_1to5(self):
    self.assertEqual([1,2,3,4,5][0], 1)

  def test_evens(self):
    self.assertEqual([2,4,6,8][0], 2)

if __name__ == '__main__':
    unittest.predominant()

Pyret

test:
  empty.first raises "no longer-found"
  [list: 1,2,3,4,5].first is 1
  [list: 2,4,6,8].first is 2
discontinue

Structured Data

Being ready to notify records successfully is central to designing and
structuring packages. Pyret provides trim mechanisms for writing records
definitions without the cognitive or syntactic overhead of classes. We
judge the supreme procedure __init__ will no longer was this
generation’s public static void is that Python textbooks
own begun to shun structured records, returning us to the 1970s when
all the pieces used to be squeezed into a single-dimensional records structure.

Python

class BinTree:
  circulation
class leaf(BinTree):
  def __init__(self):
    circulation
class node(BinTree):
  def __init__(self, v, l, r):
    self.v = v
    self.l = l
    self.r = r

Pyret

records BinTree:
  | leaf
  | node(v, l, r)
discontinue

Structural Data

Pyret is flexible within the employ of structured records, and exposes a
straightforward object pattern underlying it to permit for structural code
alongside extra nominal patterns.

OCaml

kind animal =
  | Elephant of string float
  | Tiger of string float
  | Horse of string int
  ...

let name_of_animal a =
  match a with
    | Elephant(name, _)
    | Tiger(name, _)
    | Horse(name, _) -> name
    ...

Pyret

records Animal:
  | elephant(name, weight)
  | tiger(name, stripes)
  | horse(name, races-received)
  ...
discontinue

stress-free animal-name(a :: Animal):
  a.name
discontinue

Racket

(struct elephant (name weight))
(struct tiger (name stripes))
(struct horse (name races-received))
...

(outline (animal-name a)
  (cond
    [(elephant? a) (elephant-name a)]
    [(tiger? a) (tiger-name a)]
    [(horse? a) (horse-name a)]
    ...))

Pyret

records Animal:
  | elephant(name, weight)
  | tiger(name, stripes)
  | horse(name, races-received)
  ...
discontinue

stress-free animal-name(a :: Animal):
  a.name
discontinue

Embracing Substitutability

A create procedure of Pyret’s syntax and semantics is to include the
substitutability of comparable expressions as grand as that you just would perchance even assume. This is in
contrast to, to illustrate, some scripting languages, wherein what seems to be like
binding an expression to a non permanent name changes program behavior.

JavaScript

var o = {
  my_method: goal(x) {
    return this.y + x;
  },
  y: 10
}
o.my_method(5) === 15 // genuine
method_as_fun = o.my_method
method_as_fun(5)
// both error or NaN
// (reckoning on strict mode)

Pyret

o = {
  formulation my-formulation(self, x): self.y + x discontinue,
  y: 10
}
formulation-as-stress-free = o.my-formulation
test:
  o.my-formulation(5) is 15
  formulation-as-stress-free(5) is 15
discontinue

Ruby

o = Object.contemporary
def o.my_method(x)
  self.y + x
discontinue
def o.y
  10
discontinue
o.my_method(5) == 15 # genuine
method_as_fun = o.my_method
# Atrocious option of arguments, 0 for 1

Pyret

o = {
  formulation my-formulation(self, x): self.y + x discontinue,
  y: 10
}
formulation-as-stress-free = o.my-formulation
test:
  o.my-formulation(5) is 15
  formulation-as-stress-free(5) is 15
discontinue