Swift

Swift has type inference and a concise syntax that can make it feel more dynamic. It also supports optionals, providing developers with a flexible way to handle nullability. Swift's simplicity and strong type inference make it a compelling choice for modern application development.

Another statically typed language, Go, also emphasizes simplicity and has a clean syntax. Its interface system allows for a level of flexibility that can resemble dynamic typing, although it is still statically typed. Go's focus on simplicity and ease of use contributes to its flexibility.

More Flexible Type Inference: Crystal

Crisal, a language that tries to figure out types using clever heuristics, is known for its flexible type inference. This can make it feel like a dynamically typed language at times, although the lack of clear type inference might cause confusion. On the other hand, Crystal allows explicit type declaration in cases where it is needed.

Strictly Typed but Flexible: OCaml and Haskell

OCaml is known for its strict typing rules but offers such clear rules that developers rarely need to declare types explicitly. The compiler infers the broadest possible types and uses generics and "structural types," making it feel very flexible. Haskell is similar but its type inference, while not as good as OCaml, offers simpler approaches to polymorphism in certain cases.

These languages strike a balance between strict type safety and a flexible coding experience, making them appealing to developers who want the best of both worlds. The key is the balance between the strict rules of static typing and the flexibility of dynamic typing, allowing developers to work more intuitively.

Conclusion

While some languages are further from a static type system and have more global type inference capabilities, many other languages offer significant flexibility through powerful local type inference and type systems. This blend of strictness and flexibility makes these languages feel more dynamically typed while maintaining strong type safety. As such, they are an excellent choice for developers who wish to enjoy the benefits of modern programming languages without sacrificing the safety and performance of statically typed systems.