core — examples

← all topics · 698 examples · page 8 of 14 · raw source ↓

ILEmitterTests_Returns__Returns_Clause_Sees_Cross_Method_Resolution_With_DataType

core runnable verified

Runs `go` → 2

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Returns.cs::Returns_Clause_Sees_Cross_Method_Resolution_With_DataType   topic: core   status: verified
// verified behavior: Test.go(...) == 2

namespace Test

class Counter {
    returns Counter
    n: int

    init(n: int) { self.n = n }

    func inc() { return Counter(self.n + 1) }
    func twice() { return self.inc().inc() }
}

func go() -> int { return Counter(0).twice().n }

ILEmitterTests_Returns__Returns_Is_Still_Valid_Identifier_Elsewhere

core runnable verified

Runs `go` → 11

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_Returns.cs::Returns_Is_Still_Valid_Identifier_Elsewhere   topic: core   status: verified
// verified behavior: Test.go(...) == 11

namespace Test

func go(returns: int) -> int { return returns + 1 }

ILEmitterTests_StdlibReadiness__C02_GenericInterface_TwoParams

core runnable verified

Runs `go` → 9

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StdlibReadiness.cs::C02_GenericInterface_TwoParams   topic: core   status: verified
// verified behavior: Test.go(...) == 9

namespace Test
interface IMap<K, V> { func get(k: K) -> V }
class One<K, V> : IMap<K, V> {
    val: V
    init(v: V) { self.val = v }
    func get(k: K) -> V = self.val
}
func use(m: IMap<string, int>) -> int = m.get("x")
func go() -> int {
    let o = One<string, int>(9)
    return use(o)
}

ILEmitterTests_StdlibReadiness__C04_MultiParam_ReturnsEach

core runnable verified

Runs `go` → 13

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StdlibReadiness.cs::C04_MultiParam_ReturnsEach   topic: core   status: verified
// verified behavior: Test.go(...) == 13

namespace Test
interface IPair<A, B> {
    func left() -> A
    func right() -> B
}
class P<A, B> : IPair<A, B> {
    a: A
    b: B
    init(x: A, y: B) { self.a = x self.b = y }
    func left() -> A = self.a
    func right() -> B = self.b
}
func go() -> int {
    let p = P<int, int>(3, 10)
    let ip: IPair<int, int> = p
    return ip.left() + ip.right()
}

ILEmitterTests_StdlibReadiness__H10_UserFunc_TakesFuncParam

core runnable verified ×2

Runs `go` → 15

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StdlibReadiness.cs::H10_UserFunc_TakesFuncParam   topic: core   status: verified
// verified behavior: Test.go(...) == 15

namespace Test
func apply(f: Func<int, int>, x: int) -> int = f(x)
func go() -> int = apply((n) => n + 5, 10)

ILEmitterTests_StringEquality__ChainedEquality

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::ChainedEquality   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let a = "a"
  let b = "a"
  let c = "a"
  return a == b && b == c
}

ILEmitterTests_StringEquality__CharComparisonNotEqual

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::CharComparisonNotEqual   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let s = "abc"
  return s[0] != 'z'
}

ILEmitterTests_StringEquality__CharComparisonStillCeq

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::CharComparisonStillCeq   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let s = "a b"
  return s[1] == ' '
}

ILEmitterTests_StringEquality__ConcatEqualsLiteral

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::ConcatEqualsLiteral   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let a = "ab"
  let b = "a" + "b"
  return a == b
}

ILEmitterTests_StringEquality__EmptyStringEquality

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::EmptyStringEquality   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let a = ""
  let b = "x".Substring(0, 0)
  return a == b
}

ILEmitterTests_StringEquality__EqualityFeedingReturn

core runnable verified

Runs `go` → false

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::EqualityFeedingReturn   topic: core   status: verified
// verified behavior: Test.go(...) == false

func go() -> bool {
  let a = "abc"
  let b = "abd"
  return a == b
}

ILEmitterTests_StringEquality__EqualityInIfCondition

core runnable verified

Runs `go` → 1

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::EqualityInIfCondition   topic: core   status: verified
// verified behavior: Test.go(...) == 1

func classify(s: string) -> int {
  if s == "fail" { return 1 }
  return 0
}
func go() -> int = classify("fail")

ILEmitterTests_StringEquality__EqualityInIfCondition_NotTaken

core runnable verified

Runs `go` → 0

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::EqualityInIfCondition_NotTaken   topic: core   status: verified
// verified behavior: Test.go(...) == 0

func classify(s: string) -> int {
  if s == "fail" { return 1 }
  return 0
}
func go() -> int = classify("ok")

ILEmitterTests_StringEquality__EqualityInWhileGuard

core runnable verified

Runs `go` → 3

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::EqualityInWhileGuard   topic: core   status: verified
// verified behavior: Test.go(...) == 3

func go() -> int {
  var n = 0
  var s = "go"
  while s == "go" {
    n += 1
    if n >= 3 { s = "stop" }
  }
  return n
}

ILEmitterTests_StringEquality__NotEqual_False

core runnable verified

Runs `go` → false

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::NotEqual_False   topic: core   status: verified
// verified behavior: Test.go(...) == false

func go() -> bool {
  let a = "x"
  let b = "x" + ""
  return a != b
}

ILEmitterTests_StringEquality__NotEqual_True

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::NotEqual_True   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let a = "x"
  let b = "y"
  return a != b
}

ILEmitterTests_StringEquality__ParamEqualsLiteral_False

core runnable verified

Runs `go` → false

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::ParamEqualsLiteral_False   topic: core   status: verified
// verified behavior: Test.go(...) == false

func eq(s: string) -> bool = s == "hello"
func go() -> bool = eq("world")

ILEmitterTests_StringEquality__ParamEqualsLiteral_True

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::ParamEqualsLiteral_True   topic: core   status: verified
// verified behavior: Test.go(...) == true

func eq(s: string) -> bool = s == "hello"
func go() -> bool = eq("hello")

ILEmitterTests_StringEquality__SubstringEqualsLiteral

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::SubstringEqualsLiteral   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let s = "hello"
  let h = s.Substring(0, 3)
  return h == "hel"
}

ILEmitterTests_StringEquality__TwoRuntimeStringsEqual

core runnable verified

Runs `go` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_StringEquality.cs::TwoRuntimeStringsEqual   topic: core   status: verified
// verified behavior: Test.go(...) == true

func go() -> bool {
  let a = "foo" + "bar"
  let b = "foob" + "ar"
  return a == b
}

ILEmitterTests_TaskFunc__Task_Is_Still_Valid_Identifier_Elsewhere

core runnable verified

Runs `go` → 11

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests_TaskFunc.cs::Task_Is_Still_Valid_Identifier_Elsewhere   topic: core   status: verified
// verified behavior: Test.go(...) == 11

namespace Test

func go(task: int) -> int { return task + 1 }

ILEmitterTests2__Absolute_Value_Pin

core runnable verified

Runs `abs` → 0

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Absolute_Value_Pin   topic: core   status: verified
// verified behavior: Test.abs(...) == 0

namespace Test

func abs(n: int) -> int {
    if n < 0 {
        return -n
    }
    return n
}

ILEmitterTests2__Block_Scoped_Let_Visible_After_Block

core runnable verified

Runs `test` → 30

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Block_Scoped_Let_Visible_After_Block   topic: core   status: verified
// verified behavior: Test.test(...) == 30

namespace Test

func test() -> int {
    var total = 0
    var i = 0
    while i < 3 {
        let inner = i * 10
        total = total + inner
        i = i + 1
    }
    return total
}

ILEmitterTests2__Both_Branches_Return_Same_Type_Pin

core runnable verified

Runs `choose` → 200

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Both_Branches_Return_Same_Type_Pin   topic: core   status: verified
// verified behavior: Test.choose(...) == 200

namespace Test

func choose(flag: bool) -> int {
    if flag {
        return 100
    }
    return 200
}

ILEmitterTests2__Break_From_Inner_Of_Nested_Loops

core runnable verified

Runs `test` → 6

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Break_From_Inner_Of_Nested_Loops   topic: core   status: verified
// verified behavior: Test.test(...) == 6

namespace Test

func test() -> int {
    var outer = 0
    var i = 0
    while i < 3 {
        var j = 0
        while j < 10 {
            if j == 2 {
                break
            }
            outer = outer + 1
            j = j + 1
        }
        i = i + 1
    }
    return outer
}

ILEmitterTests2__Clamp_Idiom_Pin

core runnable verified

Runs `clamp` → 7

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Clamp_Idiom_Pin   topic: core   status: verified
// verified behavior: Test.clamp(...) == 7

namespace Test

func clamp(n: int, lo: int, hi: int) -> int {
    if n < lo {
        return lo
    }
    if n > hi {
        return hi
    }
    return n
}

ILEmitterTests2__Collatz_Length_Pin

core runnable verified

Runs `collatz_steps` → 8

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Collatz_Length_Pin   topic: core   status: verified
// verified behavior: Test.collatz_steps(...) == 8

namespace Test

func collatz_steps(n: int) -> int {
    var x = n
    var steps = 0
    while x > 1 {
        if x % 2 == 0 {
            x = x / 2
        } else {
            x = x * 3 + 1
        }
        steps = steps + 1
    }
    return steps
}

ILEmitterTests2__Comparison_All_Operators

core runnable verified

Runs `test` → 101010

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Comparison_All_Operators   topic: core   status: verified
// verified behavior: Test.test(...) == 101010

namespace Test

func test(a: int, b: int) -> int {
    var result = 0
    if a == b { result = result + 1 }
    if a != b { result = result + 10 }
    if a < b  { result = result + 100 }
    if a > b  { result = result + 1000 }
    if a <= b { result = result + 10000 }
    if a >= b { result = result + 100000 }
    return result
}

ILEmitterTests2__Conditional_Chain_With_StringConcat_Pin

core runnable verified

Runs `describe` → "grade: F"

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Conditional_Chain_With_StringConcat_Pin   topic: core   status: verified
// verified behavior: Test.describe(...) == "grade: F"

namespace Test

func describe(score: int) -> string {
    var label = ""
    if score >= 90 {
        label = "A"
    }
    if score >= 80 && score < 90 {
        label = "B"
    }
    if score >= 70 && score < 80 {
        label = "C"
    }
    if score < 70 {
        label = "F"
    }
    return "grade: " + label
}

ILEmitterTests2__Continue_From_Inner_Of_Nested_Loops

core runnable verified

Runs `test` → 9

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Continue_From_Inner_Of_Nested_Loops   topic: core   status: verified
// verified behavior: Test.test(...) == 9

namespace Test

func test() -> int {
    var total = 0
    var i = 0
    while i < 3 {
        var j = 0
        while j < 4 {
            j = j + 1
            if j == 2 {
                continue
            }
            total = total + 1
        }
        i = i + 1
    }
    return total
}

ILEmitterTests2__Count_Set_Bits_Pin

core runnable verified

Runs `popcount` → 1

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Count_Set_Bits_Pin   topic: core   status: verified
// verified behavior: Test.popcount(...) == 1

namespace Test

func popcount(n: int) -> int {
    var count = 0
    var x = n
    while x > 0 {
        if x % 2 == 1 {
            count = count + 1
        }
        x = x / 2
    }
    return count
}

ILEmitterTests2__Defer_LIFO_Ordering

core runnable verified

Runs `test` → "X"

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Defer_LIFO_Ordering   topic: core   status: verified
// verified behavior: Test.test(...) == "X"

namespace Test

func test() -> string {
    var s = ""
    defer { s = s + "C" }
    defer { s = s + "B" }
    defer { s = s + "A" }
    s = s + "X"
    return s
}

ILEmitterTests2__Defer_Runs_On_Early_Return

core runnable verified

Runs `test` → ".early"

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Defer_Runs_On_Early_Return   topic: core   status: verified
// verified behavior: Test.test(...) == ".early"

namespace Test

func test() -> string {
    var trace = ""
    defer { trace = trace + "D" }
    if true {
        return trace + ".early"
    }
    return trace
}

ILEmitterTests2__DigitSum_Via_While_Pin

core runnable verified

Runs `digit_sum` → 1

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::DigitSum_Via_While_Pin   topic: core   status: verified
// verified behavior: Test.digit_sum(...) == 1

namespace Test

func digit_sum(n: int) -> int {
    var total = 0
    var x = n
    while x > 0 {
        total = total + x % 10
        x = x / 10
    }
    return total
}

ILEmitterTests2__Factorial_Recursive_Pin

core runnable verified

Runs `fact` → 3628800

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Factorial_Recursive_Pin   topic: core   status: verified
// verified behavior: Test.fact(...) == 3628800

namespace Test

func fact(n: int) -> int {
    if n <= 1 {
        return 1
    }
    return n * fact(n - 1)
}

ILEmitterTests2__Fibonacci_Iterative_Pin

core runnable verified

Runs `fib` → 6765

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Fibonacci_Iterative_Pin   topic: core   status: verified
// verified behavior: Test.fib(...) == 6765

namespace Test

func fib(n: int) -> int {
    if n < 2 {
        return n
    }
    var a = 0
    var b = 1
    var i = 2
    while i <= n {
        let next = a + b
        a = b
        b = next
        i = i + 1
    }
    return b
}

ILEmitterTests2__Fibonacci_Recursive_Pin

core runnable verified

Runs `fib` → 55

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Fibonacci_Recursive_Pin   topic: core   status: verified
// verified behavior: Test.fib(...) == 55

namespace Test

func fib(n: int) -> int {
    if n < 2 {
        return n
    }
    return fib(n - 1) + fib(n - 2)
}

ILEmitterTests2__Float_Add_Double

core runnable verified

Runs `test` → 3.5

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Float_Add_Double   topic: core   status: verified
// verified behavior: Test.test(...) == 3.5

namespace Test

func test(a: double, b: double) -> double = a + b

ILEmitterTests2__Float_Div_Double

core runnable verified

Runs `test` → 2.5

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Float_Div_Double   topic: core   status: verified
// verified behavior: Test.test(...) == 2.5

namespace Test

func test(a: double, b: double) -> double = a / b

ILEmitterTests2__Float_Mul_Double

core runnable verified

Runs `test` → 6.0

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Float_Mul_Double   topic: core   status: verified
// verified behavior: Test.test(...) == 6.0

namespace Test

func test(a: double, b: double) -> double = a * b

ILEmitterTests2__Float_Sub_Double

core runnable verified

Runs `test` → 0.75

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Float_Sub_Double   topic: core   status: verified
// verified behavior: Test.test(...) == 0.75

namespace Test

func test(a: double, b: double) -> double = a - b

ILEmitterTests2__Function_Literal_Captures_Let

core runnable verified

Runs `test` → 10

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Function_Literal_Captures_Let   topic: core   status: verified
// verified behavior: Test.test(...) == 10

namespace Test

func test() -> int {
    let x = 10
    let read = func() -> int = x
    return read()
}

ILEmitterTests2__Function_Multiple_Returns_Via_If_Else

core runnable verified

Runs `sign` → 0

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Function_Multiple_Returns_Via_If_Else   topic: core   status: verified
// verified behavior: Test.sign(...) == 0

namespace Test

func sign(n: int) -> int {
    if n > 0 { return 1 }
    if n < 0 { return -1 }
    return 0
}

ILEmitterTests2__Function_Returning_Bool_From_Comparison

core runnable verified

Runs `is_even` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Function_Returning_Bool_From_Comparison   topic: core   status: verified
// verified behavior: Test.is_even(...) == true

namespace Test

func is_even(n: int) -> bool = n % 2 == 0

ILEmitterTests2__GCD_Euclidean_Pin

core runnable verified

Runs `gcd` → 7

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::GCD_Euclidean_Pin   topic: core   status: verified
// verified behavior: Test.gcd(...) == 7

namespace Test

func gcd(a: int, b: int) -> int {
    var x = a
    var y = b
    while y != 0 {
        let t = y
        y = x % y
        x = t
    }
    return x
}

ILEmitterTests2__Helper_Function_Side_Effects_Through_Return_Pin

core runnable verified

Runs `sum_squares` → 385

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::Helper_Function_Side_Effects_Through_Return_Pin   topic: core   status: verified
// verified behavior: Test.sum_squares(...) == 385

namespace Test

func square(n: int) -> int = n * n

func sum_squares(n: int) -> int {
    var total = 0
    var i = 1
    while i <= n {
        total = total + square(i)
        i = i + 1
    }
    return total
}

ILEmitterTests2__If_As_Statement_Returns_From_Branch

core runnable verified

Runs `test` → "zero"

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::If_As_Statement_Returns_From_Branch   topic: core   status: verified
// verified behavior: Test.test(...) == "zero"

namespace Test

func test(n: int) -> string {
    if n > 0 {
        return "positive"
    }
    if n < 0 {
        return "negative"
    }
    return "zero"
}

ILEmitterTests2__If_Mutates_Outer_Var

core runnable verified

Runs `test` → 0

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::If_Mutates_Outer_Var   topic: core   status: verified
// verified behavior: Test.test(...) == 0

namespace Test

func test(n: int) -> int {
    var result = 0
    if n > 0 {
        result = 1
    }
    if n < 0 {
        result = -1
    }
    return result
}

ILEmitterTests2__IntegerSquareRoot_BinarySearch_Pin

core runnable verified

Runs `isqrt` → 31

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::IntegerSquareRoot_BinarySearch_Pin   topic: core   status: verified
// verified behavior: Test.isqrt(...) == 31

namespace Test

func isqrt(n: int) -> int {
    if n < 2 {
        return n
    }
    var lo = 0
    var hi = n
    while lo < hi {
        let mid = (lo + hi + 1) / 2
        if mid * mid <= n {
            lo = mid
        }
        if mid * mid > n {
            hi = mid - 1
        }
    }
    return lo
}

ILEmitterTests2__IsPrime_Trial_Division_Pin

core runnable verified

Runs `is_prime` → true

// E# — a verified example from the E# language corpus (CLR language; .es, not ECMAScript).
// provenance: ILEmitterTests2.cs::IsPrime_Trial_Division_Pin   topic: core   status: verified
// verified behavior: Test.is_prime(...) == true

namespace Test

func is_prime(n: int) -> bool {
    if n < 2 {
        return false
    }
    if n == 2 {
        return true
    }
    if n % 2 == 0 {
        return false
    }
    var d = 3
    while d * d <= n {
        if n % d == 0 {
            return false
        }
        d = d + 2
    }
    return true
}

← prev 8 / 14 next →