Skip to content

Triangle

Classify a triangle by its three side lengths as equilateral, isosceles or scalene.

Adapted from Exercism’s problem specification (MIT). Listed under Numbers & Math.

// FILE: triangle.nomi
//# Whether a triangle is equilateral, isosceles or scalene.

/// What a triangle's sides say about its shape.
pub enum Kind
    Equilateral
    Isosceles
    Scalene
end

/// Classifies three side lengths, or answers `None` when they do not make a
/// triangle: a side is not positive, or one side is longer than the other two
/// together.
pub fn kind((a, b, c): (Float, Float, Float)) -> Maybe<Kind>
    positive = a > 0.0 and b > 0.0 and c > 0.0
    inequality = a + b >= c and b + c >= a and a + c >= b
    if not (positive and inequality) then return None

    case [a, b, c] |> Iter.to_set() |> Set.size()
        1 -> Some(.Equilateral)
        2 -> Some(.Isosceles)
        _ -> Some(.Scalene)
    end
end

/// All three sides are equal.
pub fn is_equilateral(sides: (Float, Float, Float)) -> Bool
    kind(sides) == Some(.Equilateral)
end

/// At least two sides are equal, so every equilateral triangle is isosceles.
pub fn is_isosceles(sides: (Float, Float, Float)) -> Bool
    kind(sides) is Some(.Equilateral or .Isosceles)
end

/// No two sides are equal.
pub fn is_scalene(sides: (Float, Float, Float)) -> Bool
    kind(sides) == Some(.Scalene)
end

// FILE: triangle_test.nomi
import triangle

test "equilateral triangle"
    [
        ("all sides are equal",              (2.0, 2.0, 2.0), True),
        ("any side is unequal",              (2.0, 3.0, 2.0), False),
        ("no sides are equal",               (5.0, 4.0, 6.0), False),
        ("all zero sides is not a triangle", (0.0, 0.0, 0.0), False),
        ("sides may be floats",              (0.5, 0.5, 0.5), True),
    ]
    |> subtests (description, sides, expected), description
        assert triangle.is_equilateral(sides) == expected
    end
end

test "isosceles triangle"
    [
        ("last two sides are equal",                 (3.0, 4.0, 4.0), True),
        ("first two sides are equal",                (4.0, 4.0, 3.0), True),
        ("first and last sides are equal",           (4.0, 3.0, 4.0), True),
        ("equilateral triangles are also isosceles", (4.0, 4.0, 4.0), True),
        ("no sides are equal",                       (2.0, 3.0, 4.0), False),
        ("first triangle inequality violation",      (1.0, 1.0, 3.0), False),
        ("second triangle inequality violation",     (1.0, 3.0, 1.0), False),
        ("third triangle inequality violation",      (3.0, 1.0, 1.0), False),
        ("sides may be floats",                      (0.5, 0.4, 0.5), True),
    ]
    |> subtests (description, sides, expected), description
        assert triangle.is_isosceles(sides) == expected
    end
end

test "scalene triangle"
    [
        ("no sides are equal",                  (5.0, 4.0, 6.0), True),
        ("all sides are equal",                 (4.0, 4.0, 4.0), False),
        ("first and second sides are equal",    (4.0, 4.0, 3.0), False),
        ("first and third sides are equal",     (3.0, 4.0, 3.0), False),
        ("second and third sides are equal",    (4.0, 3.0, 3.0), False),
        ("may not violate triangle inequality", (7.0, 3.0, 2.0), False),
        ("sides may be floats",                 (0.5, 0.4, 0.6), True),
    ]
    |> subtests (description, sides, expected), description
        assert triangle.is_scalene(sides) == expected
    end
end
  • Sides are a (Float, Float, Float) tuple, since the canonical data includes fractional sides and Nomi does not mix Int and Float. Whole sides are written 2.0.
  • kind answers Maybe<Kind> over a Kind enum, None for a non-triangle; the three canonical predicates are thin wrappers over it.
  • The kind comes from the size of the set of sides (1, 2 or 3 distinct lengths) rather than pairwise comparisons.
  • Each canonical group is a test named by the group’s description, holding one subtests table; a group block is for shared clock, boot or setup, which none needs.
  • is_isosceles is kind(sides) is Some(.Equilateral or .Isosceles): the or sits inside the payload, so one test says both kinds count.