Skip to content

Instantly share code, notes, and snippets.

@coreh
Created October 5, 2012 21:02
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save coreh/3842388 to your computer and use it in GitHub Desktop.
Save coreh/3842388 to your computer and use it in GitHub Desktop.

Arquivo em branco

Código Fonte

(arquivo em branco)

Saída

statement list

Comentários

Código Fonte

/* This is a 
multiline 
comment */

// This is a single line comment

Saída

statement list

Literais

Código Fonte

// Number literals
2;
2.0;
2e+0;

// String literals
'test';
"test";
'test with "';
"test with '";
"test with escape sequences\n\t\"";
'test with escape sequences\n\t\"';

// Object literals
{};
{ foo: 1 };
{ foo: 1, bar: 2 };
{ foo: 1, bar: 2, foobar: { foo: 1 }};
{ 'foo': 1 };
{ 'foo': 1, 'foo': 2 };
{ 'foo': 1, 'foo': 2, 'foo': { foo: 1 }};
{ 1: 'a' };

// Function literals
take x, y, z { };
do { };

Saída

statement list
  expression
    number literal 2
  expression
    number literal 2.0
  expression
    number literal 2e+0
  expression
    string literal 'test'
  expression
    string literal "test"
  expression
    string literal 'test with "'
  expression
    string literal "test with '"
  expression
    string literal "test with escape sequences\n\t\""
  expression
    string literal 'test with escape sequences\n\t\"'
  expression
    object literal
  expression
    object literal
      identifier foo
      number literal 1
  expression
    object literal
      identifier foo
      number literal 1
      identifier bar
      number literal 2
  expression
    object literal
      identifier foo
      number literal 1
      identifier bar
      number literal 2
      identifier foobar
      object literal
        identifier foo
        number literal 1
  expression
    object literal
      string literal 'foo'
      number literal 1
  expression
    object literal
      string literal 'foo'
      number literal 1
      string literal 'foo'
      number literal 2
  expression
    object literal
      string literal 'foo'
      number literal 1
      string literal 'foo'
      number literal 2
      string literal 'foo'
      object literal
        identifier foo
        number literal 1
  expression
    object literal
      number literal 1
      string literal 'a'
  expression
    function literal
      declaration list
        declaration
          identifier x
        declaration
          identifier y
        declaration
          identifier z
      statement list
  expression
    function literal
      statement list

Constantes

Código Fonte

// var constants
this;

// bool constants
true;
false;
yes;
no;
on;
off;

// float constants
NaN;
infinity;

// void* constants
null;

// void constants
undefined;

Saída

statement list
  expression
    constant \this
  expression
    constant \true
  expression
    constant \false
  expression
    constant \yes
  expression
    constant \no
  expression
    constant \on
  expression
    constant \off
  expression
    constant \NaN
  expression
    constant \infinity
  expression
    constant \null
  expression
    constant \undefined

Comandos

Código Fonte

if true {
  
};

if true {
  
} else {
  
};

if true {
  
} else if false {
  
};

for x in [] {
  
};

while true {
  break;
  continue;
};

return;

Saída

statement list
  if statement
    expression
      constant \true
    statement list
  if statement
    expression
      constant \true
    statement list
    statement list
  if statement
    expression
      constant \true
    statement list
    if statement
      expression
        constant \false
      statement list
  for statement
    identifier x
    expression
      array literal
    statement list
  while statement
    expression
      constant \true
    statement list
      break statement
      continue statement
  return statement

Inserção Automática de Ponto e Vírgulas

Código Fonte

// Semicolons
if (true) {
  1;
  2;
  3;
  return 5;
  if (false) {
    return 7
  };
} else {
  take x { };
  return 6;
};

// Without Semicolons
if (true) {
  1
  2
  3
  return 5
  if (false) {
    return 7
  }
} else {
  take x { }
  return 6
}

Saída

statement list
  if statement
    expression
      constant \true
    statement list
      expression
        number literal 1
      expression
        number literal 2
      expression
        number literal 3
      return statement
        expression
          number literal 5
      if statement
        expression
          constant \false
        statement list
          return statement
            expression
              number literal 7
    statement list
      expression
        function literal
          declaration list
            declaration
              identifier x
          statement list
      return statement
        expression
          number literal 6
  if statement
    expression
      constant \true
    statement list
      expression
        number literal 1
      expression
        number literal 2
      expression
        number literal 3
      return statement
        expression
          number literal 5
      if statement
        expression
          constant \false
        statement list
          return statement
            expression
              number literal 7
    statement list
      expression
        function literal
          declaration list
            declaration
              identifier x
          statement list
      return statement
        expression
          number literal 6

Inserção Automática de Vírgulas

Código Fonte

// Commas
[ 
  1,
  2, 
  3,
  4
];

{
  a: 1,
  b: 2, 
  c: 3
};

// Without commas
[ 
  1
  2
  3
  4
];

{
  a: 1
  b: 2
  c: 3
};

Saída

statement list
  expression
    array literal
      number literal 1
      number literal 2
      number literal 3
      number literal 4
  expression
    object literal
      identifier a
      number literal 1
      identifier b
      number literal 2
      identifier c
      number literal 3
  expression
    array literal
      number literal 1
      number literal 2
      number literal 3
      number literal 4
  expression
    object literal
      identifier a
      number literal 1
      identifier b
      number literal 2
      identifier c
      number literal 3

Expressões

Código Fonte

2 + 2 == 4

-((3 * 5 + 2) / 7)

(400 - 32)/14 + 9 >> 5 & 3

true || false

Saída

statement list
  expression
    equality expression
      addition expression
        number literal 2
        addition operator +
        number literal 2
      equality operator ==
      addition expression
        number literal 4
        addition operator -
        expression
          multiplication expression
            expression
              addition expression
                multiplication expression
                  number literal 3
                  multiplication operator *
                  number literal 5
                addition operator +
                number literal 2
            multiplication operator /
            number literal 7
  expression
    bitwise expression
      bitshift expression
        addition expression
          multiplication expression
            expression
              addition expression
                number literal 400
                addition operator -
                number literal 32
            multiplication operator /
            number literal 14
          addition operator +
          number literal 9
        bitshift operator >>
        number literal 5
      bitwise and operator &
      number literal 3
  expression
    logical expression
      constant \true
      logical or operator ||
      constant \false

Variáveis

Código Fonte

var a

int b
int8 c
int16 d
int32 e
int64 f

uint g
uint8 h
uint16 i
uint32 j
uint64 k

float l
float32 m
float64 n

bool o

void* p

int() q 
int(int) r 
int(int,float) s

// With initialization
var a2 = this

int b2 = 1
int8 c2 = 1
int16 d2 = 1
int32 e2 = 1
int64 f2 = 1

uint g2 = 1
uint8 h2 = 1
uint16 i2 = 1
uint32 j2 = 1
uint64 k2 = 1

float l2 = 1.0
float32 m2 = 1.0
float64 n2 = 1.0

bool o2 = true

void* p2 = null

void() q2 = do {}
int(int) r2 = take x { return 1 }
float(int,float) s2 = take x, y { return 1.0 }

Saída

statement list
  declaration statement
    type
      keyword \var
    declaration list
      declaration
        identifier a
  declaration statement
    type
      keyword \int
    declaration list
      declaration
        identifier b
  declaration statement
    type
      keyword \int8
    declaration list
      declaration
        identifier c
  declaration statement
    type
      keyword \int16
    declaration list
      declaration
        identifier d
  declaration statement
    type
      keyword \int32
    declaration list
      declaration
        identifier e
  declaration statement
    type
      keyword \int64
    declaration list
      declaration
        identifier f
  declaration statement
    type
      keyword \uint
    declaration list
      declaration
        identifier g
  declaration statement
    type
      keyword \uint8
    declaration list
      declaration
        identifier h
  declaration statement
    type
      keyword \uint16
    declaration list
      declaration
        identifier i
  declaration statement
    type
      keyword \uint32
    declaration list
      declaration
        identifier j
  declaration statement
    type
      keyword \uint64
    declaration list
      declaration
        identifier k
  declaration statement
    type
      keyword \float
    declaration list
      declaration
        identifier l
  declaration statement
    type
      keyword \float32
    declaration list
      declaration
        identifier m
  declaration statement
    type
      keyword \float64
    declaration list
      declaration
        identifier n
  declaration statement
    type
      keyword \bool
    declaration list
      declaration
        identifier o
  declaration statement
    type
      multiplication operator *
      type
        keyword \void
    declaration list
      declaration
        identifier p
  declaration statement
    type
      type
        keyword \int
      type list
    declaration list
      declaration
        identifier q
  declaration statement
    type
      type
        keyword \int
      type list
        type
          keyword \int
    declaration list
      declaration
        identifier r
  declaration statement
    type
      type
        keyword \int
      type list
        type
          keyword \int
        type
          keyword \float
    declaration list
      declaration
        identifier s
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier a2
        assignment operator =
        constant \this
  declaration statement
    type
      keyword \int
    declaration list
      assignment expression
        declaration
          identifier b2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \int8
    declaration list
      assignment expression
        declaration
          identifier c2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \int16
    declaration list
      assignment expression
        declaration
          identifier d2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \int32
    declaration list
      assignment expression
        declaration
          identifier e2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \int64
    declaration list
      assignment expression
        declaration
          identifier f2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \uint
    declaration list
      assignment expression
        declaration
          identifier g2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \uint8
    declaration list
      assignment expression
        declaration
          identifier h2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \uint16
    declaration list
      assignment expression
        declaration
          identifier i2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \uint32
    declaration list
      assignment expression
        declaration
          identifier j2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \uint64
    declaration list
      assignment expression
        declaration
          identifier k2
        assignment operator =
        number literal 1
  declaration statement
    type
      keyword \float
    declaration list
      assignment expression
        declaration
          identifier l2
        assignment operator =
        number literal 1.0
  declaration statement
    type
      keyword \float32
    declaration list
      assignment expression
        declaration
          identifier m2
        assignment operator =
        number literal 1.0
  declaration statement
    type
      keyword \float64
    declaration list
      assignment expression
        declaration
          identifier n2
        assignment operator =
        number literal 1.0
  declaration statement
    type
      keyword \bool
    declaration list
      assignment expression
        declaration
          identifier o2
        assignment operator =
        constant \true
  declaration statement
    type
      multiplication operator *
      type
        keyword \void
    declaration list
      assignment expression
        declaration
          identifier p2
        assignment operator =
        constant \null
  declaration statement
    type
      type
        keyword \void
      type list
    declaration list
      assignment expression
        declaration
          identifier q2
        assignment operator =
        function literal
          statement list
  declaration statement
    type
      type
        keyword \int
      type list
        type
          keyword \int
    declaration list
      assignment expression
        declaration
          identifier r2
        assignment operator =
        function literal
          declaration list
            declaration
              identifier x
          statement list
            return statement
              expression
                number literal 1
  declaration statement
    type
      type
        keyword \float
      type list
        type
          keyword \int
        type
          keyword \float
    declaration list
      assignment expression
        declaration
          identifier s2
        assignment operator =
        function literal
          declaration list
            declaration
              identifier x
            declaration
              identifier y
          statement list
            return statement
              expression
                number literal 1.0

Marca de Indentação

Código Fonte

if true {
  if true {
    1;
  } else {
    2;
  } 
} else {
  if true {
    3;
  } else {
    4;
  }
}

if true ->
  if true ->
    1;
  else ->
    2; 
else ->
  if true ->
    3;
  else ->
    4;


if true ->
  if true -> 1;
  else -> 2; 
else ->
  if true -> 3;
  else -> 4;

Saída

statement list
  if statement
    expression
      constant \true
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 1
        statement list
          expression
            number literal 2
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 3
        statement list
          expression
            number literal 4
  if statement
    expression
      constant \true
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 1
        statement list
          expression
            number literal 2
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 3
        statement list
          expression
            number literal 4
  if statement
    expression
      constant \true
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 1
        statement list
          expression
            number literal 2
    statement list
      if statement
        expression
          constant \true
        statement list
          expression
            number literal 3
        statement list
          expression
            number literal 4

Escopo

Código Fonte

int a;
int x = a;
do {
  int b;
  int x = a + b;
  do {
    int c;
    int x = a + b + c;
    do {
      int d;
      int x = a + b + c + d;
      do {
        int e;
        int x = a + b + c + d + e;
        do {
          int f;
          int x = a + b + c + d + e + f;
        }
      }
    }
  }
}

Saída

statement list
  declaration statement
    type
      keyword \int
    declaration list
      declaration
        identifier a
  declaration statement
    type
      keyword \int
    declaration list
      assignment expression
        declaration
          identifier x
        assignment operator =
        variable
          identifier a
  expression
    function literal
      statement list
        declaration statement
          type
            keyword \int
          declaration list
            declaration
              identifier b
        declaration statement
          type
            keyword \int
          declaration list
            assignment expression
              declaration
                identifier x
              assignment operator =
              addition expression
                variable
                  identifier a
                addition operator +
                variable
                  identifier b
        expression
          function literal
            statement list
              declaration statement
                type
                  keyword \int
                declaration list
                  declaration
                    identifier c
              declaration statement
                type
                  keyword \int
                declaration list
                  assignment expression
                    declaration
                      identifier x
                    assignment operator =
                    addition expression
                      addition expression
                        variable
                          identifier a
                        addition operator +
                        variable
                          identifier b
                      addition operator +
                      variable
                        identifier c
              expression
                function literal
                  statement list
                    declaration statement
                      type
                        keyword \int
                      declaration list
                        declaration
                          identifier d
                    declaration statement
                      type
                        keyword \int
                      declaration list
                        assignment expression
                          declaration
                            identifier x
                          assignment operator =
                          addition expression
                            addition expression
                              addition expression
                                variable
                                  identifier a
                                addition operator +
                                variable
                                  identifier b
                              addition operator +
                              variable
                                identifier c
                            addition operator +
                            variable
                              identifier d
                    expression
                      function literal
                        statement list
                          declaration statement
                            type
                              keyword \int
                            declaration list
                              declaration
                                identifier e
                          declaration statement
                            type
                              keyword \int
                            declaration list
                              assignment expression
                                declaration
                                  identifier x
                                assignment operator =
                                addition expression
                                  addition expression
                                    addition expression
                                      addition expression
                                        variable
                                          identifier a
                                        addition operator +
                                        variable
                                          identifier b
                                      addition operator +
                                      variable
                                        identifier c
                                    addition operator +
                                    variable
                                      identifier d
                                  addition operator +
                                  variable
                                    identifier e
                          expression
                            function literal
                              statement list
                                declaration statement
                                  type
                                    keyword \int
                                  declaration list
                                    declaration
                                      identifier f
                                declaration statement
                                  type
                                    keyword \int
                                  declaration list
                                    assignment expression
                                      declaration
                                        identifier x
                                      assignment operator =
                                      addition expression
                                        addition expression
                                          addition expression
                                            addition expression
                                              addition expression
                                                variable
                                                  identifier a
                                                addition operator +
                                                variable
                                                  identifier b
                                              addition operator +
                                              variable
                                                identifier c
                                            addition operator +
                                            variable
                                              identifier d
                                          addition operator +
                                          variable
                                            identifier e
                                        addition operator +
                                        variable
                                          identifier f

Exportação

Código Fonte

export float(float,float) multiply = take x, y -> return x * y
export int oneHundred = 100

Saída

statement list
  export statement
    declaration statement
      type
        type
          keyword \float
        type list
          type
            keyword \float
          type
            keyword \float
      declaration list
        assignment expression
          declaration
            identifier multiply
          assignment operator =
          function literal
            declaration list
              declaration
                identifier x
              declaration
                identifier y
            statement list
              return statement
                expression
                  multiplication expression
                    variable
                      identifier x
                    multiplication operator *
                    variable
                      identifier y
  export statement
    declaration statement
      type
        keyword \int
      declaration list
        assignment expression
          declaration
            identifier oneHundred
          assignment operator =
          number literal 100

Importação

Código Fonte

import math
import sqrt from math
import pow, pi from math
import one from ../mock

Saída

statement list
  import statement
    import path
      identifier math
  import from statement
    import path
      identifier sqrt
    import path
      identifier math
  import from statement
    import path
      identifier pow
    import path
      identifier pi
    import path
      identifier math
  import from statement
    import path
      identifier one
    import path
      dot .
      dot .
      multiplication operator /
      identifier mock

Herança Prototipal

Código Fonte

import pi, sqrt, pow, atan2 from math

var Positionable = take x, y ->
  this.x = x
  this.y = y

Positionable::angle = take that ->
  return atan2(this.y - that.y, this.x - that.x)
  
Positionable::distance = take that ->
  return sqrt(pow(this.x - that.x, 2) + pow(this.y - that.y, 2))

var Circle = take x, y, r ->
  this : Positionable(x, y)
  this.r = r
  
Circle::circumference = do -> return 2 * pi * this.r

Circle::area = do -> return pi * this.r * this.r

/* This is a method override */
Circle::distance = take that ->
  return this!Positionable::distance(that) - this.r - that.r

var c1 = new Circle(0, 0, 3)
var c2 = new Circle(10, 7, 5)

var a = c1.area()
var d = c1.distance(c2)

Saída

statement list
  import from statement
    import path
      identifier pi
    import path
      identifier sqrt
    import path
      identifier pow
    import path
      identifier atan2
    import path
      identifier math
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier Positionable
        assignment operator =
        function literal
          declaration list
            declaration
              identifier x
            declaration
              identifier y
          statement list
            expression
              assignment expression
                literal member expression
                  constant \this
                  identifier x
                assignment operator =
                variable
                  identifier x
            expression
              assignment expression
                literal member expression
                  constant \this
                  identifier y
                assignment operator =
                variable
                  identifier y
  expression
    assignment expression
      literal prototype expression
        variable
          identifier Positionable
        identifier angle
      assignment operator =
      function literal
        declaration list
          declaration
            identifier that
        statement list
          return statement
            expression
              call expression
                variable
                  identifier atan2
                expression
                  addition expression
                    literal member expression
                      constant \this
                      identifier y
                    addition operator -
                    literal member expression
                      variable
                        identifier that
                      identifier y
                  addition expression
                    literal member expression
                      constant \this
                      identifier x
                    addition operator -
                    literal member expression
                      variable
                        identifier that
                      identifier x
  expression
    assignment expression
      literal prototype expression
        variable
          identifier Positionable
        identifier distance
      assignment operator =
      function literal
        declaration list
          declaration
            identifier that
        statement list
          return statement
            expression
              call expression
                variable
                  identifier sqrt
                expression
                  addition expression
                    call expression
                      variable
                        identifier pow
                      expression
                        addition expression
                          literal member expression
                            constant \this
                            identifier x
                          addition operator -
                          literal member expression
                            variable
                              identifier that
                            identifier x
                        number literal 2
                    addition operator +
                    call expression
                      variable
                        identifier pow
                      expression
                        addition expression
                          literal member expression
                            constant \this
                            identifier y
                          addition operator -
                          literal member expression
                            variable
                              identifier that
                            identifier y
                        number literal 2
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier Circle
        assignment operator =
        function literal
          declaration list
            declaration
              identifier x
            declaration
              identifier y
            declaration
              identifier r
          statement list
            expression
              inheritance expression
                constant \this
                colon :
                call expression
                  variable
                    identifier Positionable
                  expression
                    variable
                      identifier x
                    variable
                      identifier y
            expression
              assignment expression
                literal member expression
                  constant \this
                  identifier r
                assignment operator =
                variable
                  identifier r
  expression
    assignment expression
      literal prototype expression
        variable
          identifier Circle
        identifier circumference
      assignment operator =
      function literal
        statement list
          return statement
            expression
              multiplication expression
                multiplication expression
                  number literal 2
                  multiplication operator *
                  variable
                    identifier pi
                multiplication operator *
                literal member expression
                  constant \this
                  identifier r
  expression
    assignment expression
      literal prototype expression
        variable
          identifier Circle
        identifier area
      assignment operator =
      function literal
        statement list
          return statement
            expression
              multiplication expression
                multiplication expression
                  variable
                    identifier pi
                  multiplication operator *
                  literal member expression
                    constant \this
                    identifier r
                multiplication operator *
                literal member expression
                  constant \this
                  identifier r
  expression
    assignment expression
      literal prototype expression
        variable
          identifier Circle
        identifier distance
      assignment operator =
      function literal
        declaration list
          declaration
            identifier that
        statement list
          return statement
            expression
              addition expression
                addition expression
                  apply expression
                    constant \this
                    bang !
                    call expression
                      literal prototype expression
                        variable
                          identifier Positionable
                        identifier distance
                      expression
                        variable
                          identifier that
                  addition operator -
                  literal member expression
                    constant \this
                    identifier r
                addition operator -
                literal member expression
                  variable
                    identifier that
                  identifier r
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier c1
        assignment operator =
        inheritance expression
          object literal
          colon :
          call expression
            variable
              identifier Circle
            expression
              number literal 0
              number literal 0
              number literal 3
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier c2
        assignment operator =
        inheritance expression
          object literal
          colon :
          call expression
            variable
              identifier Circle
            expression
              number literal 10
              number literal 7
              number literal 5
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier a
        assignment operator =
        call expression
          literal member expression
            variable
              identifier c1
            identifier area
  declaration statement
    type
      keyword \var
    declaration list
      assignment expression
        declaration
          identifier d
        assignment operator =
        call expression
          literal member expression
            variable
              identifier c1
            identifier distance
          expression
            variable
              identifier c2

Erro Léxico

Código Fonte

2+2+#

Saída

tests/rejection/001.lexical.k (line 1: column 5) error: Invalid token.
2+2+#
    ^

tests/rejection/001.lexical.k (line 1: column 5) error: Expected a value
2+2+#
    ^

Erros Sintáticos

Código Fonte

int int x

if true { doSomething[) )

Saída

tests/rejection/002.syntax.k (line 3: column 23) error: Mismatched braces.
if true { doSomething[) )
                      ^

tests/rejection/002.syntax.k (line 3: column 25) error: Mismatched braces.
if true { doSomething[) )
                        ^

tests/rejection/002.syntax.k (line 1: column 9) error: Expected `;` after variable declaration.
int int x
        ^

tests/rejection/002.syntax.k (line 3: column 11) error: Use of undeclared identifier `doSomething`.
if true { doSomething[) )
          ^

tests/rejection/002.syntax.k (line 3: column 23) error: Expected a value
if true { doSomething[) )
                  ^

tests/rejection/002.syntax.k (line 3: column 26) error: Expected end of block.
if true { doSomething[) )
                         ^

Erro Semântico: Existência

Código Fonte

int x, y

x = y + z

Saída

tests/rejection/003.existence.k (line 3: column 9) error: Use of undeclared identifier `z`.
x = y + z
        ^

tests/rejection/003.existence.k (line 1: column 5) note: Did you mean `x`, declared here?
int x, y
    ^

Erro Semântico: Unicidade

Código Fonte

int x
float x

Saída

tests/rejection/004.unicity.k (line 2: column 7) error: Redeclaration of `x`.
float x
      ^

tests/rejection/004.unicity.k (line 1: column 5) note: Previous declaration is here.
int x
    ^

Erro Semântico: Tipo

Código Fonte

int x = true

float y = take z { return z + 1 }

bool z = &x

int* a = 3.4

int8 b = 128

int8 c = -129

uint d = -1

var x = z + x

Saída

tests/rejection/005.type.k (line 1: column 7) error: Cannot assign `bool` into `int` without data loss.
int x = true
      ^

tests/rejection/005.type.k (line 1: column 9) note: Use a typecast to perform the conversion explicity.
int x = true
        ^

tests/rejection/005.type.k (line 3: column 9) error: Cannot assign `uint=1(var)` into `float`.
float y = take z { return z + 1 }
        ^

tests/rejection/005.type.k (line 5: column 8) error: Cannot assign `int*` into `bool`.
bool z = &x
       ^

tests/rejection/005.type.k (line 7: column 8) error: Cannot assign `float32` into `int*`.
int* a = 3.4
       ^

tests/rejection/005.type.k (line 9: column 8) error: Cannot assign `uint=128` into `int8` without data loss.
int8 b = 128
       ^

tests/rejection/005.type.k (line 9: column 10) note: Use a typecast to perform the conversion explicity.
int8 b = 128
         ^

tests/rejection/005.type.k (line 11: column 8) error: Cannot assign `uint=-129` into `int8` without data loss.
int8 c = -129
       ^

tests/rejection/005.type.k (line 11: column 10) note: Use a typecast to perform the conversion explicity.
int8 c = -129
         ^

tests/rejection/005.type.k (line 15: column 5) error: Redeclaration of `x`.
var x = z + x
    ^

tests/rejection/005.type.k (line 1: column 5) note: Previous declaration is here.
int x = true
    ^

tests/rejection/005.type.k (line 15: column 9) error: Cannot perform addition with operand of type `bool`.
var x = z + x
        ^

tests/rejection/005.type.k (line 15: column 11) error: Cannot convert implicitly between types `bool` and `int` without data loss.
var x = z + x
          ^

tests/rejection/005.type.k (line 15: column 13) note: Use a typecast to perform the conversion explicitly.
var x = z + x
            ^

Erro Semântico: Importação

Código Fonte

import foo
import jellybeans from math

Saída

tests/rejection/006.imports.k (line 1: column 8) error: Could not resolve module `foo`.
import foo
       ^

tests/rejection/006.imports.k (line 3: column 8) error: Module `math` does not export `jellybeans`.
import jellybeans from math
       ^
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment