Lattice-linearity was introduced as a way to model problems using predicates that induce a lattice among the global states (Garg, SPAA 2020). A key property of \textit{the predicate} representing such problems is that it induces \textit{one} lattice in the state space. An algorithm that emerges from such a predicate guarantees the execution to be correct even if nodes execute asynchronously. However, many interesting problems do not exhibit lattice-linearity. This issue was somewhat alleviated with the introduction of eventually lattice-linear algorithms (Gupta and Kulkarni, SSS 2021). They induce \textit{single} or \textit{multiple} lattices in \textit{a subset of the state space} even when the problem cannot be defined by a predicate under which the global states form a lattice. This paper focuses on analyzing and differentiating between lattice-linear problems and algorithms. We introduce \textit{fully lattice-linear algorithms}. These algorithms partition the \textit{entire} reachable state space into \textit{one or more lattices}, and as a result, ensure that the execution remains correct even if nodes execute asynchronously. For demonstration, we present lattice-linear self-stabilizing algorithms for minimal dominating set (MDS), graph colouring (GC), minimal vertex cover (MVC) and maximal independent set (MIS) problems. The algorithms for MDS, MVC and MIS converge in $n$ moves and the algorithm for GC converges in $n+2m$ moves. These algorithms preserve this time complexity while allowing the nodes to execute asynchronously. They present an improvement to the existing algorithms present in the literature. Our work also demonstrates that to allow asynchrony, a more relaxed data structure can be allowed (called $\prec$-lattice in this paper, where the meet of a pair of global states may not be defined), rather than a distributive lattice as assumed by Garg.