Fibonacci Sequence - Mercury Typing CST Test

Mode:

Duration:

:- module fib.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- func fib(int) = int.
fib(N) = (if N =< 1 then N else fib(N-1) + fib(N-2)).

main(!IO) :-
	for I = 0 to 9 do io.write_int(fib(I), !IO), io.write_string("\n", !IO).Coding works best on desktop or with an external keyboard.

Fibonacci Sequence — Mercury Code

Generates first 10 Fibonacci numbers using a pure predicate.

:- module fib.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- func fib(int) = int.
fib(N) = (if N =< 1 then N else fib(N-1) + fib(N-2)).

main(!IO) :-
	for I = 0 to 9 do io.write_int(fib(I), !IO), io.write_string("\n", !IO).

Mercury Language Guide

Mercury is a purely declarative logic programming language with strong typing, determinism analysis, and a focus on reliability and performance. It is designed for building large-scale, maintainable, and efficient logic programs while avoiding common pitfalls of traditional Prolog systems.

Primary Use Cases

▸Logic-based and symbolic programming
▸Constraint solving
▸Knowledge representation
▸Formal verification and theorem proving
▸Academic research and teaching

Notable Features

▸Purely declarative semantics
▸Strong, static type system
▸Mode and determinism checking
▸High-performance compiler
▸Separation of logic and control flow

Origin & Creator

Mercury was created in the mid-1990s by Zoltan Somogyi, Fergus Henderson, and Thomas Conway at the University of Melbourne, building on ideas from Prolog but with stricter type and mode systems.

Industrial Note

Mercury is used in academic research, formal verification, symbolic computation, and complex rule-based systems. While not mainstream, it is highly valued in areas requiring highly reliable logic programs.

Quick Explain

▸Mercury emphasizes declarative programming, separating logic from control flow.
▸It provides a strong static type system and mode system for arguments.
▸Mercury’s compiler optimizes for performance and guarantees no runtime type errors for well-typed programs.

Core Features

▸Predicates and functions with explicit types
▸Modes defining input/output arguments
▸Determinism categories (det, semidet, nondet, multi)
▸Module system for code organization
▸Automatic memory management and garbage collection

Learning Path

▸Learn basic logic programming concepts
▸Understand types, modes, and determinism
▸Practice predicate and function definitions
▸Build small logic modules
▸Progress to large declarative systems

Practical Examples

▸Family tree reasoning
▸Constraint satisfaction problems
▸Symbolic math computations
▸Natural language parsing
▸Rule-based expert systems

Comparisons

▸Mercury vs Prolog: stronger typing, mode and determinism system, better performance
▸Mercury vs Haskell: functional vs logic paradigm, Mercury is declarative logic
▸Mercury vs Python: specialized for logic, smaller ecosystem
▸Mercury vs Lisp: symbolic computation vs declarative logic
▸Mercury vs C: higher-level declarative logic, less low-level control

Strengths

▸Eliminates many runtime errors via type and mode checking
▸Predictable declarative behavior
▸Efficient execution through optimized compilation
▸Highly maintainable large logic programs
▸Facilitates reasoning about program correctness

Limitations

▸Smaller ecosystem and community
▸Steeper learning curve than Prolog for beginners
▸Limited libraries for modern software development
▸Not suitable for mainstream web or mobile apps
▸Requires strict adherence to modes and types

When NOT to Use

▸Web and mobile application development
▸Real-time embedded systems
▸Mainstream commercial software without logic reasoning
▸Large-scale GUI applications
▸Performance-critical numeric computing outside logic domain

Cheat Sheet

▸:- module family.
▸:- interface.
▸:- import_module io.
▸:- pred parent(string, string).
▸parent('Alice', 'Bob').

FAQ

▸Is Mercury still in use?
▸Yes, primarily in research and education.
▸Can Mercury integrate with C?
▸Yes, via Foreign Function Interface (FFI).
▸Is Mercury purely functional?
▸It is purely declarative logic-based, not functional in the Haskell sense.
▸Why learn Mercury?
▸To build reliable logic-based programs and understand advanced logic programming concepts.

30-Day Skill Plan

▸Week 1: Mercury syntax and types
▸Week 2: Modes and determinism
▸Week 3: Predicate and function writing
▸Week 4: Module-based projects
▸Week 5: Constraint solving and symbolic computation

Final Summary

▸Mercury is a strongly typed, purely declarative logic programming language for building reliable, maintainable logic programs.
▸It combines type, mode, and determinism analysis with high-performance compilation.
▸Ideal for research, symbolic computation, and complex logic systems.

Project Structure

▸Source files (.m)
▸Interface files (.m)
▸Modules for code organization
▸Test cases for predicates/functions
▸Documentation files

Monetization

▸Academic research and publications
▸Symbolic computation consulting
▸Logic-based software solutions
▸Educational courses in logic programming
▸Prototyping AI and constraint systems

Productivity Tips

▸Leverage static types and modes early
▸Modularize predicates for clarity
▸Test small logic components incrementally
▸Use determinism analysis for optimization
▸Integrate FFI for performance-critical tasks

Basic Concepts

▸Predicates (relations between terms)
▸Functions (deterministic computations)
▸Types (user-defined and built-in)
▸Modes (input/output specification)
▸Determinism declarations (det, semidet, multi, nondet)

Official Docs

▸Mercury Language Reference Manual
▸Mercury Compiler User Guide
▸University of Melbourne Mercury Resources
▸Mercury Tutorials and Examples
▸Mercury FFI Documentation

More Mercury Typing Exercises

Mercury Counter and Theme Toggle Mercury Factorial Calculator Mercury Prime Checker Mercury Sum of List Mercury Reverse String Mercury Multiplication Table Mercury Celsius to Fahrenheit Mercury Simple Alarm Simulation Mercury Random Walk Simulation

Practice Other Languages

C React Python C++Rust TypeScript Kotlin PHP Java C#Ruby Mql Cql N1ql Cypher

:- module fib.
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- func fib(int) = int.
fib(N) = (if N =< 1 then N else fib(N-1) + fib(N-2)).

main(!IO) :-
for I = 0 to 9 do io.write_int(fib(I), !IO), io.write_string("\n", !IO).

Coding works best on desktop or with an external keyboard.

Fibonacci Sequence — Mercury Code

Generates first 10 Fibonacci numbers using a pure predicate.

:- module fib. :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. :- func fib(int) = int. fib(N) = (if N =< 1 then N else fib(N-1) + fib(N-2)). main(!IO) :- for I = 0 to 9 do io.write_int(fib(I), !IO), io.write_string("\n", !IO).

Mercury Language Guide

Primary Use Cases

▸Logic-based and symbolic programming
▸Constraint solving
▸Knowledge representation
▸Formal verification and theorem proving
▸Academic research and teaching

Notable Features

▸Purely declarative semantics
▸Strong, static type system
▸Mode and determinism checking
▸High-performance compiler
▸Separation of logic and control flow

Origin & Creator

Mercury was created in the mid-1990s by Zoltan Somogyi, Fergus Henderson, and Thomas Conway at the University of Melbourne, building on ideas from Prolog but with stricter type and mode systems.

Industrial Note